Pascal Super Library/Pascal Super Library (CW International)(1997).bin/DELPHI32/CALCULTR/MCALC/MCALC.PAS

Pascal/Delphi Source File | 1996-07-24 | 76KB | 1,914 lines

(*                   MathCalc 32 Multithread Kernel (Object Pascal)
                             (c) Daniel Doubrovkine
   Stolen Technologies Inc. - University of Geneva - 1996 - All Rights Reserved
                           for Scientific Calculator
                   (part of the Expression Calculator 2.0)

   Disclaimer: There's no waranty of any kind for anything and the author will
               not be help responsible for anything claimed, whatever cause or
               gravity may be.

   my homepage is at www.infomaniak.ch/~dblock

   SOURCE IS NOT FREE!

   SOURCE MAY BE USED FOR FREE IN COMPLETE AND TOTAL FREEWARE SOFTWARE ONLY, OTHERWISE
   PLEASE CONTACT ME FOR MORE DETAIL!

   ANY ILLEGAL USE OR SALE WILL BE PROSECUTED AT MAXIMUM EXTENT POSSIBLE UNDER THE
   SWISS CRIMINAL LAW!

  last minute notes:
       prime function were disabled since too much dependant from the task of the
       calculator, you must maintain external references to general prime tables

*)
unit MCalc;

interface
uses Classes, TreeView, SysUtils, Dialogs, Math, WinProcs, Forms;

type
  TCalcMode=(Deg,Rad,Hex,Bin,Oct);                                              {calculation modes currently supported}
  TCalcThread = class (TThread)
   protected
     CalcString    : string;                                                    {initital string passed for calculation}
     VarTree       : PNode;                                                     {variable tree passed, may be global!}
     CalcTree      : PNode;                                                     {calculator tree will be used for expression analysis}
     CalcMode      : TCalcMode;                                                 {calculation mode}
     CharRead      : char;                                                      {last char analysed}
     NextInteger   : integer;                                                   {next integer sign}
     CalcPos       : integer;                                                   {current position in string for analysis}
     NegativeParenthesis : boolean;                                             {internal purpose for string analysis, sign inversion for parenthesis}
     ReadNode      : PNode;                                                     {current analysis tree node}
     CalcNode      : PNode;                                                     {current calculation node}
     NewSymbol     : integer;                                                   {currently analysed symbol (sin, cos...)}
     CalcError     : Boolean;                                                   {was an error raised?}
     RaisedError   : string;                                                    {the raised error string}
     ErrorPosition : integer;                                                   {the raised error position}
     CalcResult    : extended;                                                  {the extended result of the calculation}
     CalcStrResult : string;                                                    {the string result of the calculation}
     ShortStrResult: string;                                                    {the short string result of the calculation}
     CalcId        : LongInt;                                                   {the id passed to the thread}
     procedure     Execute; override;                                           {the execute thread routine, don't override if you don't understand}
     procedure     UpdateNextInteger;                                           {update next integer sign}
     procedure     ReadItem;                                                    {read the next item at analysis}
     procedure     AnalyseExpression(Expression:PNOde);                         {analyse complete expression (recursive, but not reentrant at same thread}
     function      Evaluation(Expression:PNode):extended;                       {evaluation of a correct mathematical tree}
     (*procedure     PrimesAdd(PrimeToAdd: LongInt);*)                          {}
     function      IntToHex(AnyLong: extended):string;                          {explicit conversions}
     function      IntToBin(AnyLong: extended):string;
     function      IntToOct(AnyLong: extended):string;
   public                                                                       {creation of the calculation object}
     constructor   Create(CalculateString:string;                               {the string to analyse and to calculate}
                          MyVarTree:PNode;                                      {variable tree to use (uses TreeView)}
                          ToCalcMode:TCalcMode;                                 {calculation mode}
                          ThreadId:integer);                                    {thread id passed}
     procedure     UpdateResult; virtual;                                       {update result procedure, does necessary stuff,
                                                                                 you must override to get result or change code in unit directly}
     end;

implementation


(* RESULT CONVERSION *)
function TCalcThread.IntToHex(AnyLong: extended):string;
   function SecIntToHex(AnyLong:extended):string;
      const
      HexArray: string='0123456789ABCDEF';
      begin
      if AnyLong<16 then SecIntToHex:=HexArray[Trunc(AnyLong)+1] else
      SecIntToHex:=SecIntToHex(Trunc(AnyLong/16))+SecIntToHex(AnyLong-Trunc(AnyLong/16)*16);
      end;
   var
      IntToHexString: string;
      Sign: integer;
   begin
        if AnyLong<0 then begin
           Sign:=-1;
           AnyLong:=-AnyLong;
           end else Sign:=1;
        IntToHexString:=SecIntToHex(AnyLong);
        while Length(IntToHexString) mod 2>0 do IntToHexString:='0'+IntToHexString;
        {IntToHex:=IntToHexString;}
        if Sign=-1 then IntToHex:='-'+IntToHexString else IntToHex:=IntToHexString;
   end;

function TCalcThread.IntToBin(AnyLong: extended):string;
   function SecIntToBin(AnyLong: extended):string;
      const
      BinArray: string='01';
      begin
      if AnyLong<2 then SecIntToBin:=BinArray[Trunc(AnyLong)+1] else begin
         SecIntToBin:=SecIntToBin(Trunc(AnyLong/2))+SecIntToBin(AnyLong-Trunc(AnyLong/2)*2);
      end;
      end;
   var
      IntToBinString: string;
   begin
        IntToBinString:=SecIntToBin(AnyLong);
        while Length(IntToBinString) mod 4>0 do IntToBinString:='0'+IntToBinString;
        IntToBin:=IntToBinString;
   end;

function TCalcThread.IntToOct(AnyLong: extended):string;
      const
         OctArray: string='01234567';
      var
         Sign: integer;
         SecIntToOct: string;
      begin
      if AnyLong<0 then begin
         Sign:=-1;
         AnyLong:=-AnyLong
         end else Sign:=1;
      if AnyLong<8 then SecIntToOct:=OctArray[Trunc(AnyLong)+1] else
      SecIntToOct:=IntToOct(Trunc(AnyLong/8))+IntToOct(AnyLong-Trunc(AnyLong/8)*8);
      if Sign=-1 then IntToOct:='-'+SecIntToOct else IntToOct:=SecIntToOct;
      end;


(* THREAD CONSTRUCTOR *)
constructor TCalcThread.Create(CalculateString:string;MyVarTree:PNode;ToCalcMode:TCalcMode;ThreadId:integer);
begin
   CalcId:=ThreadId;
   FreeOnTerminate:=True;
   CalcString:=CalculateString;
   VarTree:=MyVarTree;
   CalcMode:=ToCalcMode;
   NewSymbol:=0;
   CalcError:=False;
   CharRead:=' ';
   ErrorPosition:=0;
   NextInteger:=1;
   inherited Create(False);
   end;

   (*
procedure TCalcThread.PrimesAdd(PrimeToAdd: LongInt);
begin
   {MessageDlg('Adding '+IntToStr(PrimeToAdd),mtInformation,[mbOk],0);}
   Calculator.CurrentPrime:=PrimeToAdd;
   ReAllocMem(Calculator.AllPrimes,(Calculator.PrimesCount+2)*SizeOf(LongInt));
   Calculator.AllPrimes^[Calculator.PrimesCount]:=PrimeToAdd;
   Calculator.AllPrimes^[Calculator.PrimesCount+1]:=0;
   inc(Calculator.PrimesCount);
   end;
   *)

(* THREAD EXECUTOR *)
procedure TCalcThread.Execute;
begin
   try
   New(CalcTree,Create(NodeVariable,'Calculating Tree:'));
   New(ReadNode,Create(NodeVariable,'?'));
   if VarTree=nil then New(VarTree,Create(NodeVariable,'Variable occurences.'));
   CalcNode:=CalcTree^.AddChild(NodeVariable,'Extended Calculator');
   CalcNode:=CalcNode^.AddChild(NodeVariable,'(c) Daniel Doubrovkine');
   CalcNode^.AddChild(NodeVariable,'University of Geneva - 1996');
   CalcNode:=CalcNode^.AddChild(NodeValue,'0');
   CalcPos:=1;
   UpdateNextInteger;
   if CalcError=true then begin
      UpdateResult;
      exit;
      end;
   ReadItem;
   if CalcError=true then begin
      UpdateResult;
      exit;
      end;
   AnalyseExpression(CalcNode);
   if CalcError=true then begin
      UpdateResult;
      exit;
      end;
   if (ReadNode.NodeType<>NodeOperator) or
      (ReadNode.NodeContents.MyOperator <> '$') then begin
      RaisedError:='missing operator';
      CalcError:=true;
      ErrorPosition:=CalcPos;
      end;
   if not CalcError then begin
      CalcResult:=Evaluation(CalcNode);
      if CalcError=False then begin
         Str(CalcResult,CalcStrResult);
         if (CalcStrResult='-0.0000000000') or
            (CalcStrResult='0.00000000000') then begin
            CalcResult:=0;
            CalcStrResult:='0.00';
            end;
         end;
       end;
   UpdateResult;
   exit;
   except
      CalcError:=True;
      RaisedError:='abnormal exception, rerun the thread';
      ErrorPosition:=0;
      UpdateResult;
      exit;
      end;
   end;


(* THREAD RESULT UPDATER *)
procedure TCalcThread.UpdateResult;
var
   i,j,k: integer;
begin
      if CalcError=False then begin
         try
            ShortStrResult:='';
            if CalcMode=Bin then begin
               if (CalcResult>=0) and (Trunc(CalcResult)=CalcResult) then
                  ShortStrResult:=IntToBin(trunc(CalcResult))
                  else begin
                  ShortStrResult:='- E -';
                  CalcStrResult:='non integer or negative result';
                  end;
                  end else
               if CalcMode=Oct then begin
                  if (Trunc(CalcResult)=CalcResult) then
                  ShortStrResult:=IntToOct(trunc(CalcResult))
                  else begin
                  ShortStrResult:='- E -';
                  CalcStrResult:='non integer result';
                  end;
                  end else
               if CalcMode=Hex then begin
                  if (Trunc(CalcResult)=CalcResult) then
                  ShortStrResult:=IntToHex(trunc(CalcResult))
                  else begin
                  ShortStrResult:='- E -';
                  CalcStrResult:='non integer result';
                  end;
               end else begin
            CalcStrResult:=Trim(CalcStrResult);

            for i:=1 to Length(CalcStrResult) do if CalcStrResult[i]='E' then break;
            if i<Length(CalcStrResult) then
               CalcStrResult:=Trim(Copy(CalcStrResult,1,i-1)+'e'+Copy(CalcStrResult,i+1,Length(CalcStrResult)));
            Str(CalcResult:0:2,ShortStrResult);
            ShortStrResult:=Trim(ShortStrResult);
            for i:=1 to Length(ShortStrResult) do if ShortStrResult[i]='E' then begin
               ShortStrResult:=CalcStrResult;
               break;
               end;
            end;
          except
          ShortStrResult:='N/A';
          end;

       CalcStrResult:=Trim(CalcStrResult);
       for i:=1 to Length(CalcStrResult) do if CalcStrResult[i]='E' then break;
       if i<Length(CalcStrResult) then CalcStrResult:=Trim(Copy(CalcStrResult,1,i-1)+'e'+Copy(CalcStrResult,i+1,Length(CalcStrResult)));

       if ShortStrResult='-0.00' then begin
          ShortStrResult:='0.00';
          for i:=1 to Length(CalcStrResult) do if CalcStrResult[i]='e' then break;
          j:=0;
          if i<Length(CalcStrResult) then Val(Copy(CalcStrResult,i+1,Length(CalcStrResult)),j,k);
          if j<-10 then CalcStrResult:='0.00000000000000e+0000';
          CalcResult:=0;
          end;
      end;
   end;

(* NEXT INTEGER SIGN *)
procedure TCalcThread.UpdateNextInteger;
begin
   NextInteger:=0;
   if CalcString[CalcPos]='-' then NextInteger:=-1;
   if CalcString[CalcPos]='+' then NextInteger:=1;
   if NextInteger<>0 then CalcPos:=CalcPos+1 else NextInteger:=1;
   end;

(*GET NEXT ITEM FROM STRING*)
procedure TCalcThread.ReadItem;
   function CheckVariableTable(variable:string):PNode;
   begin
      CheckVariableTable:=VarTree^.FindItem(NodeVariable,variable);
      end; {CheckVariableTable}
   procedure ReadCh; {gets the next char}
   begin
      if CalcPos>Length(CalcString) then
         CharRead := '$'
      else begin
         CharRead:=CalcString[CalcPos];
         inc(CalcPos);
         end; {else}
      end; {ReadCh}
   function ReadOctNumber:extended;
   var
      MyNumber:extended;
   begin
      try
      MyNumber:=0;
      while CharRead in ['0'..'7'] do begin
            MyNumber := MyNumber * 8 + (ord(CharRead)-ord('0'));
            ReadCh;
            end;{while}
      ReadOctNumber:=MyNumber*NextInteger;
      except
         CalcError:=true;
         RaisedError := 'octal overflow';
         ErrorPosition:= CalcPos;
         ReadOctNumber:=0;
         exit;
      end;
      end;
   function ReadBinNumber:extended;
   var
      MyNumber:extended;
   begin
      try
      MyNumber:=0;
      while CharRead in ['0'..'1'] do begin
        MyNumber := MyNumber * 2 + (ord(CharRead)-ord('0'));
        ReadCh;
      end;{while}
      ReadBinNumber:=MyNumber*NextInteger;
      except
         CalcError:=true;
         RaisedError := 'binary digit overflow';
         ErrorPosition:= CalcPos;
         ReadBinNumber:=0;
         exit;
      end;
      end;
   function ReadHexNumber:extended;
   var
      MyNumber:extended;
   begin
      try
      MyNumber:=0;
      while CharRead in ['0'..'9','A'..'F'] do begin
         if CharRead in ['0'..'9'] then
            MyNumber := MyNumber * 16 + (ord(CharRead)-ord('0'))
            else
            MyNumber := MyNumber * 16 + (ord(CharRead)-ord('A')+10);
         ReadCh;
      end;{while}
      ReadHExNumber:=MyNumber*NextInteger;
      except
         CalcError:=true;
         RaisedError := 'hexadecimal overflow';
         ErrorPosition:= CalcPos;
         ReadHexNumber:=0;
         exit;
      end;
      end;{ReadNumber}
   {check variable table for a variable, returns a pointer if node found}
   function ReadNumber:extended;
   var
      MyNumber:extended;
      dCounter:extended;
   begin
      try
      MyNumber:=0;
      while CharRead in ['0'..'9'] do begin
         MyNumber := MyNumber * 10 + (ord(CharRead)-ord('0'));
         ReadCh;
      end;{while}
      dCounter:=1;
      if (CharRead='.') then begin
         ReadCh;
         while CharRead in ['0'..'9'] do begin
            MyNumber:=MyNumber*10 + (ord(CharRead)-ord('0'));
            DCounter:=DCounter*10;
            ReadCh;
            end;{while}
         end;{if}
      MyNumber:=MyNumber/DCounter;
      if NextInteger<>0 then begin
         MyNumber:=MyNumber*NextInteger;
         NextInteger:=0;
         end;{if}
      ReadNumber:=MyNumber;
      except
         CalcError:=true;
         RaisedError := 'decimal overflow';
         ErrorPosition:= CalcPos;
         ReadNumber:=0;
         exit;
      end;
      end;{ReadNumber}
   {check variable table for a variable, returns a pointer if node found}

 procedure ReadNotDecimal;
   var {ReadItem}
   SymbolProc:string;
 begin
   NegativeParenthesis:=False;
   if CalcError=true then exit;
   while CharRead=' ' do ReadCh;
   with ReadNode^ do begin
      case CharRead of
         '0'..'9','A'..'F' : begin
         {read an unsigned integer}
                       NodeType:=NodeValue;
                       if (CalcMode=hex) then NodeContents^.MyValue:=ReadHexNumber;
                       if (CalcMode=bin) then NodeContents^.MyValue:=ReadBinNumber;
                       if (CalcMode=oct) then NodeContents^.MyValue:=ReadOctNumber;
                       end;{'0'..'9'}
         'S','H','L','R','a'..'z' : begin
                       SymbolProc:='';
                              while CharRead in ['S','H','L','R','a'..'z'] do begin
                                    SymbolProc:=SymbolProc+CharRead;
                                    ReadCh;
                                    end;{while}
                                 if (CompareText(SymbolProc,'or')=0) or
                                    (CompareText(SymbolProc,'and')=0) or
                                    (CompareText(SymbolProc,'xor')=0) or
                                    (CompareText(SymbolProc,'nor')=0) or
                                    (CompareText(SymbolProc,'xnor')=0) or
                                    (CompareText(SymbolProc,'nand')=0) then begin
                                     CalcPos:=CalcPos-1;
                                     NodeType:=NodeOperator;
                                     NodeContents^.MyOperator:=SymbolProc;
                                     ReadCh;
                                 end else begin
                                     NodeType:=NodeSingle;
                                     NodeContents^.MySingle:=SymbolProc;
                                     if NextInteger=-1 then NodeContents.MySingle:='-'+NodeContents.MySingle;
                                     end;{else begin}

                                 end;{'A'..'z'}
         '(': begin
                 if NextInteger=-1 then NegativeParenthesis:=True;
                 UpdateNextInteger;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 Readch;
              end;
         '+','-','*','/','^','%',',': begin
                 UpdateNextInteger;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 ReadCh;
                 end;
         '!',')','$' : begin
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 ReadCh;
                 end;
         else begin {else case}
                 CalcError:=true;
                 RaisedError := 'invalid character';
                 ErrorPosition:= CalcPos;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:='$';
                 end;{else}
         end;{case}
      end;{with}
   end;
 procedure ReadDegRad;
   var {ReadItem}
   SymbolProc:string;
   TempVarString:string;
   TempVarValue:extended;
   TempNode:PNode;
   TempStoreNode:PNode;
   l:integer;
 begin {ReadDegRad}
   NegativeParenthesis:=False;
   if CalcError=true then exit;
   while CharRead=' ' do ReadCh;
   with ReadNode^ do begin
      case CharRead of
         '.','0'..'9' : begin
         {read an unsigned integer}
                       NodeType:=NodeValue;
                       NodeContents^.MyValue:=ReadNumber;
                       end;{'0'..'9'}
         'A'..'Z', 'a'..'z' : begin
                                 SymbolProc:='';
                                 while CharRead in ['A'..'Z','a'..'z'] do begin
                                       SymbolProc:=SymbolProc+CharRead;
                                       ReadCh;
                                       end;{while}
                                 if (CompareText(SymbolProc,'or')=0) or
                                    (CompareText(SymbolProc,'and')=0) or
                                    (CompareText(SymbolProc,'xor')=0) or
                                    (CompareText(SymbolProc,'nor')=0) or
                                    (CompareText(SymbolProc,'xnor')=0) or
                                    (CompareText(SymbolProc,'nand')=0) or
                                    (SymbolProc='\') or
                                    (SymbolProc='m') or
                                    (SymbolProc='e') then begin
                                     CalcPos:=CalcPos-1;
                                     UpdateNextInteger;
                                     NodeType:=NodeOperator;
                                     NodeContents^.MyOperator:=SymbolProc;
                                     ReadCh;
                                 end else
                                 if (SymbolProc<>'E') and
                                    (Length(SymbolProc)=1) then begin
                                     NodeType:=NodeVariable;
                                     NodeContents^.MyVariable := SymbolProc;
                                     TempNode:=CheckVariableTable(SymbolProc[1]);
                                     TempStoreNode:=TempNode;
                                     if TempNode<>nil then
                                     if NewSymbol>0 then begin
                                        {TempNode.Remove;}
                                        TempNode:=nil;
                                        end;
                                     if TempNode=nil then begin
                                        TempNode:=VarTree^.AddChild(NodeVariable,SymbolProc[1]);
                                        l:=1;
                                        while (l<>0) do begin
                                        if InputQuery('Variable prompt', 'Please enter a value for '+SymbolProc[1], TempVarString)=False then begin
                                           CalcError:=True;
                                           ErrorPosition:=CalcPos;
                                           RaisedError:='cancelled at var assignment';
                                           TempNode^.Remove;
                                           exit;
                                           end;
                                        TempVarString:=Trim(TempVarString);
                                        if CompareText(TempVarString,'pi')=0 then Str(Pi,TempVarString) else
                                        if TempVarString='E' then Str(Exp(1.0),TempVarString);
                                        Val(TempVarString,TempVarValue,l);
                                        if TempVarValue=1 then;
                                        end;
                                        if TempStoreNode<>nil then TempStoreNode.Remove;
                                        TempNode^.AddChild(NodeValue,Trim(TempVarString));
                                       end;
                                        NodeType:=NodeValue;
                                        Val(CheckVariableTable(SymbolProc[1])^.Child(0)^.Contents,TempVarValue,l);
                                        NodeContents^.MyValue:=NextInteger*TempVarValue;
                                     end{<>'E'}
                                 else begin
                                         if CompareText(SymbolProc,'pi')=0 then begin
                                             NodeType:=NodeValue;
                                             NodeContents^.MyValue:=NextInteger*Pi;
                                             end{if}
                                         else
                                             if SymbolProc='E' then begin
                                                NodeType:=NodeValue;
                                                NodeContents^.MyValue:=NextInteger*Exp(1.0);
                                                end{='E'}
                                             else begin
                                                if (CompareText(SymbolProc,'new')=0) then inc(NewSymbol);
                                                NodeType:=NodeSingle;
                                                NodeContents^.MySingle:=SymbolProc;
                                                if NextInteger=-1 then NodeContents.MySingle:='-'+NodeContents.MySingle;
                                             end;
                                         end;{else begin}
                                 end;{'A'..'z'}
         '(': begin
                 if NextInteger=-1 then NegativeParenthesis:=True;
                 UpdateNextInteger;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 Readch;
              end;
         '+','-','*','/','^','ª','%','\': begin
                 UpdateNextInteger;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 ReadCh;
                 end;
         ',': begin
                 UpdateNextInteger;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 ReadCh;
              end;
         '!',')','$' : begin
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:=CharRead;
                 ReadCh;
                 end;
         else begin {else case}
                  CalcError:=true;
                  RaisedError := 'invalid character';
                  ErrorPosition:= CalcPos;
                 NodeType:=NodeOperator;
                 NodeContents^.MyOperator:='$';
                 end;{else}
         end;{case}
      end;{with}
      end;
   begin {ReadItem}
      if (CalcMode<>Deg) and (CalcMode<>Rad) then ReadNotDecimal else ReadDegRad;
   end;{ReadItem}


(* TRIANGULAR EXPRESSION ANALYSIS, THE VERY BEST WAY TO ANALYSE AN EXPRESSION WITH
   PRIORITIES *)
procedure TCalcThread.AnalyseExpression(Expression:PNode);
  procedure Term(Expression:PNode);
   procedure Percentage(Expression:PNode);
    procedure AnyRoot(Expression:PNode);
     procedure Power(Expression:PNode);
      procedure TenPower(Expression:PNode);
       procedure Factor(Expression:PNode);
        procedure Operator(Expression:PNode);
         function ct(MyCompareText:string):boolean;
         begin
           if (CompareText(Expression^.Contents,MyCompareText)=0)
           or (CompareText(Expression^.Contents,'-'+MyCompareText)=0) then ct:=true else ct:=false;
           end;
          var
             NegativeLocalParenthesis:boolean;
             ParamCount:integer;
             ParamRead: integer;
          begin
             NegativeLocalParenthesis:=False;
             if (ReadNode^.NodeType=NodeSingle) then begin
                 ParamCount:=0;
                 Expression^.NodeType:=NodeSingle;
                 Expression^.NodeContents^.MySingle:=ReadNode^.NodeContents^.MySingle;

                 if ct('binom') then ParamCount:=1 else
                 if ct('logn') then ParamCount:=1 else
                 if ct('max') then ParamCount:=-1 else
                 if ct('min') then ParamCount:=-1 else
                 if ct('shr') then ParamCount:=1 else
                 if ct('shl') then ParamCount:=1 else
                 if ct('gcd') then ParamCount:=-1 else
                 if ct('pgcd') then ParamCount:=-1 else
                 if ct('gamma') then ParamCount:=1 else
                 if ct('beta') then ParamCount:=2 else
                 if ct('lcm') then ParamCount:=-1 else
                 if ct('ppcm') then ParamCount:=-1 else
                 if ct('average') then ParamCount:=-1;

                 if not(ct('new')) and (NewSymbol>0) then inc(NewSymbol);
                 ReadItem;
                 if CalcError=true then exit;

               if (ReadNode^.NodeType<>NodeOperator) or
                  (ReadNode^.NodeContents^.MyOperator<>'(') then begin
                     CalcError:=True;
                     RaisedError:='function requires "("';
                     ErrorPosition:=CalcPos;
                     exit;
                   end;

                   ReadItem;
                   if CalcError=true then exit;
                   AnalyseExpression(Expression^.AddChild(NodeValue,'0'));

               ParamRead:=1;
               if ParamCount<0 then begin
                  while (ReadNode^.NodeType=NodeOperator) and
                        (ReadNode^.NodeContents^.MyOperator=',') {and
                        (ParamRead<255)} do begin
                         ReadItem;
                         inc(ParamRead);
                         AnalyseExpression(Expression^.Addchild(NodeValue,'0'));
                         if CalcError=true then exit;
                         end;
                  if abs(ParamRead)<abs(ParamCount) then begin
                     CalcError:=True;
                     RaisedError:='insuf. params for '+Expression^.Contents;
                     ErrorPosition:=CalcPos;
                     exit;
                     end;
                  end;

               while ParamCount>0 do begin
                 if (ReadNode^.NodeType<>NodeOperator) or
                    (ReadNode^.NodeContents^.MyOperator<>',') then begin
                     CalcError:=True;
                     RaisedError:='insuf. params for '+Expression^.Contents;
                     ErrorPosition:=CalcPos;
                     exit;
                     end;
                 ReadItem;
                 AnalyseExpression(Expression^.Addchild(NodeValue,'0'));
                 ParamCount:=ParamCount-1;
                 if CalcError=true then exit;
               end;

               if (ReadNode^.NodeType<>NodeOperator) or
                  (ReadNode^.NodeContents^.MyOperator<>')') then begin
                     CalcError:=True;
                     RaisedError:='")" expected';
                     ErrorPosition:=CalcPos;
                     exit;
                   end;{')'}
                if NewSymbol>0 then NewSymbol:=NewSymbol-1;
                ReadItem;
                if CalcError=true then exit;
                end {NodeSingle} else
            if (ReadNode^.NodeType=NodeValue) then begin
                Expression^.NodeType:=NodeValue;
                Expression^.NodeContents^.MyValue:=ReadNode^.NodeContents^.MyValue;
                ReadItem;
                if CalcError=true then exit;
                end{NodeValue} else
            if (ReadNode^.NodeType=NodeVariable) then begin
                Expression^.NodeType:=NodeVariable;
                Expression^.NodeContents^.MyVariable:=ReadNode^.NodeContents^.MyVariable;
                ReadItem;
                if CalcError=true then exit;
                end {variable} else
            if (ReadNode^.NodeType=NodeOperator) and
               (ReadNode^.NodeContents^.MyOperator='(') then begin

               if NegativeParenthesis then begin
                NegativeLocalParenthesis:=True;
                if Expression^.Parent^.Child(1)=nil then begin
                   Expression^.Parent^.Child(0)^.NodeType:=NodeOperator;
                   Expression^.Parent^.Child(0)^.NodeContents^.MyOperator:='-';
                   Expression:=Expression^.Parent^.Child(0);
                   end else begin
                   Expression^.Parent^.Child(1)^.NodeType:=NodeOperator;
                   Expression^.Parent^.Child(1)^.NodeContents^.MyOperator:='-';
                   Expression:=Expression^.Parent^.Child(1);
                   end;
                  Expression^.AddChild(NodeValue,'0');
                  Expression:=Expression^.AddChild(NodeValue,'0');
                  end;
                NegativeParenthesis:=False;
                ReadItem;

                if CalcError=true then exit;
                if Expression^.Parent^.Child(1)=nil then
                AnalyseExpression(Expression^.Parent^.Child(0)) else
                AnalyseExpression(Expression^.Parent^.Child(1));
                if NegativeLocalParenthesis then Expression:=Expression^.Parent;
                if (ReadNode^.NodeType<>NodeOperator) or
                   (ReadNode^.NodeContents^.MyOperator<>')') then begin
                     CalcError:=True;
                     RaisedError:='")" expected';
                     ErrorPosition:=CalcPos;
                     exit;
                    end;{')'}
                ReadItem;
                if CalcError=true then exit;
                end {'('}
            else begin
                     CalcError:=True;
                     RaisedError:='unexpected sign, val, var or funct';
                     ErrorPosition:=CalcPos;
                     exit;
                 end; {else}
            end;{Operator}
        begin {Factor}
           Operator(Expression);
           if CalcError=true then exit;
           while (ReadNode^.NodeType=NodeOperator) and
                 (ReadNode^.NodeContents^.MyOperator='!') do begin
                  Expression:=Expression^.InsertLevel(ReadNode);
                  ReadNode^.NodeType:=NodeValue;
                  ReadNode^.NodeContents^.MyValue:=1;
                  Operator(Expression^.Parent^.Child(1));
                  if CalcError=true then exit;
                  Expression:=Expression^.Parent;
                  end;{while}
           end; {Factor}
      begin {TenPower}
         Factor(Expression);
         if CalcError=true then exit;
         while (ReadNode^.NodeType=NodeOperator) and
               (ReadNode^.NodeContents^.MyOperator='e') do begin
                ReadNode^.NodeContents^.MyOperator:='*';
                Expression:=Expression^.InsertLevel(ReadNode);
                Expression^.NodeType:=NodeOperator;
                Expression^.NodeContents^.MyOperator:='^';
                Expression^.AddChild(NodeValue,'10');
                Expression:=Expression^.AddChild(NodeValue,'0');
                ReadNode^.NodeType:=NodeValue;
                ReadNode^.NodeContents^.MyValue:=0;
                ReadItem;
                Factor(Expression^.Parent^.Child(1));
                if CalcError=true then exit;
                Expression:=Expression^.Parent;
                end;{while}
        end;{TenPower}
      begin {Power}
         TenPower(Expression);
         if CalcError=true then exit;
         while (ReadNode^.NodeType=NodeOperator) and
               (ReadNode^.NodeContents^.MyOperator='^') do begin
                Expression:=Expression^.InsertLevel(ReadNode);
                ReadItem;
                TenPower(Expression^.Parent^.Child(1));
                if CalcError=true then exit;
                Expression:=Expression^.Parent;
                end;{while}
         end;{Power}
      begin{AnyRoot}
         Power(Expression);
         if CalcError=true then exit;
         while(ReadNode^.NodeType=NodeOperator) and
              (ReadNode^.NodeContents^.MyOperator='\') do begin
              Expression:=Expression^.InsertLevel(ReadNode);
              ReadItem;
              Power(Expression^.Parent^.Child(1));
              if CalcError=true then exit;
              Expression:=Expression^.Parent;
              end;
         end;{AnyRoot}
   begin {Percentage}
        AnyRoot(Expression);
        if CalcError=true then exit;
        while (ReadNode^.NodeType=NodeOperator) and
              (ReadNode^.NodeContents^.MyOperator='%') do begin
               Expression:=Expression^.InsertLevel(ReadNode);
               ReadItem;
               AnyRoot(Expression^.Parent^.Child(1));
               if CalcError=true then exit;
               Expression:=Expression^.Parent;
               end;{while}
        end;{Percentage}
   begin {Term}
      Percentage(Expression);
      if CalcError=true then exit;
      while (ReadNode^.NodeType=NodeOperator) and
            ((CompareText(ReadNode^.NodeContents^.MyOperator,'xor')=0) or
             (CompareText(ReadNode^.NodeContents^.MyOperator,'or')=0) or
             (CompareText(ReadNode^.NodeContents^.MyOperator,'and')=0) or
             (CompareText(ReadNode^.NodeContents^.MyOperator,'nor')=0) or
             (CompareText(ReadNode^.NodeContents^.MyOperator,'xnor')=0) or
             (CompareText(ReadNode^.NodeContents^.MyOperator,'nand')=0) or

             (ReadNode^.NodeContents^.MyOperator='z') or {xnor}
             (ReadNode^.NodeContents^.MyOperator='n') or {nor}
             (ReadNode^.NodeContents^.MyOperator='d') or {nand}
             (ReadNode^.NodeContents^.MyOperator='x') or {xor}
             (ReadNode^.NodeContents^.MyOperator='o') or {or}
             (ReadNode^.NodeContents^.MyOperator='a') or {and}

             (ReadNode^.NodeContents^.MyOperator='*') or
             (ReadNode^.NodeContents^.MyOperator='/') or
             (ReadNode^.NodeContents^.MyOperator='m') or
             (ReadNode^.NodeContents^.MyOperator='ª')) do begin
              Expression:=Expression^.InsertLevel(ReadNode);
              ReadItem;
              Percentage(Expression^.Parent^.Child(1));
              if CalcError=true then exit;
              Expression:=Expression^.Parent;
              end;{while}
      end; {Term}
  begin {Expression}
     Term(Expression);
     if CalcError=true then exit;
     while (ReadNode^.NodeType=NodeOperator) and
           ((ReadNode^.NodeContents^.MyOperator='+') or
            (ReadNode^.NodeContents^.MyOperator='-')) do begin
             Expression:=Expression^.InsertLevel(ReadNode);
             ReadItem;
             Term(Expression^.Parent^.Child(1));
             if CalcError=true then exit;
             Expression:=Expression^.Parent;
             end;{while}
     end; {Expression}

(* MATHEMATICAL EVALUATION OF THE CONSTRUCTED TREE *)
function TCalcThread.Evaluation(Expression:PNode):extended;
   type
      MArray=array[0..7] of LongInt;
      PArray=array[0..4] of LongInt;
   const
      MersiennePArray:MArray=(2,3,5,7,13,17,19,31);
      MersienneArray:MArray=(3,7,31,127,8191,131071,524287,2147483647);
      PerfectArray:PArray=(6,28,496,8128,33550336);

{------- returns the closest inferiour perfect number ----------}
function Perfect(n:extended): extended;
var
      i:integer;
   begin
      if (n<6) or (n>Power(2,32)) then begin
         RaisedError:='invalid perfect bounds';
         CalcError:=true;
         ErrorPosition:=0;
         Perfect:=0;
         exit;
         end;
      for i:=4 downto 0 do begin
          if n>=PerfectArray[i] then begin
             Perfect:=PerfectArray[i];
             exit;
             end;
         end;
         Perfect:=6;
      end;
   {------- returns the generator for a mersienne number ----------}
   function MersienneP(n: extended): extended;
   var
      i:integer;
   begin
      for i:=0 to 7 do begin
          if n=MersienneArray[i] then begin
             MersienneP:=MersiennePArray[i];
             exit;
             end;
         end;
         RaisedError:='not a mersienne prime';
         CalcError:=true;
         ErrorPosition:=0;
         MersienneP:=0;
      end;
   {-------- returns a mersienne number for a mersienne generator -----------}
   function PMersienne(n: extended): extended;
   var
      i:integer;
   begin
      for i:=0 to 7 do begin
          if n=MersiennePArray[i] then begin
             PMersienne:=MersienneArray[i];
             exit;
             end;
         end;
         RaisedError:='not a mersienne generator';
         CalcError:=true;
         ErrorPosition:=0;
         PMersienne:=0;
      end;
   {------- returns the closest inferiour mersienne number known ---------------}
   function MersienneN(n: extended): extended;
   var
      i:integer;
   begin
      if (n<3) or (n>Power(2,32)) then begin
         RaisedError:='invalid mersienne bounds';
         CalcError:=true;
         ErrorPosition:=0;
         MersienneN:=0;
         exit;
         end;
      for i:=7 downto 0 do begin
          if n>=MersienneArray[i] then begin
             MersienneN:=MersienneArray[i];
             exit;
             end;
         end;
         MersienneN:=3;
      end;
   {----------- returns the closest inferiour mersienne generator known ----------------}
   function MersienneG(n: extended): extended;
   var
      i:integer;
   begin
      if (n<2) or (n>32) then begin
         RaisedError:='invalid mersienne gen bounds';
         CalcError:=true;
         ErrorPosition:=0;
         MersienneG:=0;
         exit;
         end;
      for i:=7 downto 0 do begin
          if n>=MersiennePArray[i] then begin
             MersienneG:=MersiennePArray[i];
             exit;
             end;
         end;
         MersienneG:=3;
      end;
   {- prime numbers ------- awesome multitasking routine threaded to the same table}

(*
function MyPrime(n:extended):extended;
 procedure CalculateTPrime;
    var
      CurrentPrime: LongInt;
      CurrentCounter:LongInt;
      prime:boolean;
      number,max_div,divisor:longint;
      NextWillTerminate:boolean;
      LastShownPrime: LongInt;
    begin
      Calculator.PrimeTableUser:=Handle;
      Calculator.PrimeTableInUse:=True;
      NextWillTerminate:=False;
      CurrentPrime:=Calculator.AllPrimes^[Calculator.PrimesCount-1]+2;
      LastShownPrime:=CurrentPrime;
      Calculator.CalcGrid.Cells[1,GridId]:='Current prime: '+IntToStr(CurrentPrime);
      for number:=Calculator.CurrentPrime to MaxInt do begin
         CurrentCounter:=2;
         max_div:=round(Sqrt(number)+0.5);
         divisor:=Calculator.AllPrimes^[CurrentCounter];
         prime:=number mod divisor <> 0;
         while prime and (divisor<=max_div) do begin
             prime:=number mod divisor <> 0;
             inc(CurrentCounter);
             divisor:=Calculator.AllPrimes[CurrentCounter];
             end;
        if prime then begin

        CurrentPrime:=number;

        if Calculator.AllPrimes^[Calculator.PrimesCount-1]<CurrentPrime then
           PrimesAdd(CurrentPrime);

        if (CurrentPrime-LastShownPrime>20000) then begin
           Calculator.CalcGrid.Cells[1,GridId]:='Current prime: '+IntToStr(CurrentPrime);
           LastShownPrime:=CurrentPrime;
           end;
        if NextWillTerminate=true then begin
           Calculator.PrimeTableInUse:=False;
           exit;
           end;

        if number>n then NextWillTerminate:=True;
        end;

        end;

      end;

var
   sign: integer;
   i : longint;
   begin
      if (n>-1) and (n<1) then begin
         RaisedError:='Prime requires values |x|>1';
         CalcError:=true;
         ErrorPosition:=0;
         MyPrime:=0;
         exit;
         end;
      if n>maxint then begin
         RaisedError:='prime limit too large';
         CalcError:=true;
         ErrorPosition:=0;
         MyPrime:=0;
         exit;
         end;
      if n<0 then sign:=-1 else sign:=1;
      n:=abs(n);
      while Calculator.PrimeTableInUse do begin
            Sleep(0);
            if n<=Calculator.CurrentPrime then break;
            end;
      if (n>Calculator.CurrentPrime) then CalculateTPrime;
      for i:=Calculator.PrimesCount-1 downto 0 do begin
       if n>=Calculator.AllPrimes^[i] then begin
          MyPrime:=Calculator.AllPrimes^[i]*Sign;
          exit;
          end;
      end;
      MyPrime:=0;
      RaisedError:='severe O.S. bug, please retry';
      ErrorPosition:=0;
      CalcError:=True;
   end;
*)
{- Fibonacci -}
   function Fib(n:extended):extended;
   var
   {FibArray:array[0..2] of extended;}
    FA1, FA2, FA3 : extended;
   begin
      if n<2 then Fib:=n else
      if n=2 then Fib:=1 else begin
         FA2:=1;
         FA3:=2;
         while n>3 do begin
            FA1:=FA2;
            FA2:=FA3;
            FA3:=FA1+FA3;
            n:=n-1;
            end;
            Fib:=FA3;
            end;
         end;
{- PGCD -}
   function PGCD(u,v:extended):extended;
   var
       t: extended;
   begin
      if (trunc(u)<>u) or (trunc(v)<>v) then begin
         RaisedError:='GCD requires integers';
         CalcError:=true;
         ErrorPosition:=0;
         PGCD:=0;
         exit;
         end;
      while (v<>0) do begin
         t:=u - (trunc(u / v))*v;
         u:=v;
         v:=t;
         end;
      PGCD:=abs(u);
     end;

function gcd(g:extended):extended;
var
   ChildValue: extended;
   i:integer;
begin
   i:=1;
   while (Expression^.Child(i)<>nil) do begin
         ChildValue:=Evaluation(Expression^.Child(i));
         g:=PGCD(ChildValue,g);
         inc(i);
         end;
   gcd:=g;
   end;

{-- least common multiple ---------------------------------------------------------}
function lcm(g:extended):extended;
var
   ChildValue: extended;
   i:integer;
begin
   i:=1;
   while (Expression^.Child(i)<>nil) do begin
         ChildValue:=Evaluation(Expression^.Child(i));

      if (trunc(ChildValue)<>ChildValue) or (trunc(g)<>g) then begin
         RaisedError:='LCM requires integers';
         CalcError:=true;
         ErrorPosition:=0;
         lcm:=0;
         exit;
         end;

         g:=abs(trunc(g/pgcd(g,ChildValue))*ChildValue);
         inc(i);
         end;
   lcm:=g;
   end;
{- VariableValue ---------------------------------------------------------------------}
   function VariableValue(Variable:string):extended;
   begin
         if VarTree^.FindItem(NodeVariable,Variable)=nil then
         VariableValue:=VarTree^.FindItem(NodeVariable,'-'+Variable)^.Child(0)^.NodeContents^.MyValue
         else
         VariableValue:=VarTree^.FindItem(NodeVariable,Variable)^.Child(0)^.NodeContents^.MyValue;
      end;{VariableValue}
{- Gamma -----------------------------------------------------------------------------}
function ShortGamma(Alpha:extended;Step:extended;Infinity:longint):extended;
  function GIntegral(x:extended):extended;
      begin
      GIntegral:=Power(x,Alpha-1)/Power(Exp(1),x);
      end;
     var i:extended;
         TempGamma:extended;
       begin
       if (Step>=1) or (Step=0) then begin
          CalcError:=True;
          ErrorPosition:=0;
          RaisedError:='inaccurate (>=1 ªª =0) step for gamma';
          ShortGamma:=0;
          exit;
          end;
       i:=0;
       TempGamma:=0;
       while i<Infinity do begin
        i:=i+Step;
        TempGamma:=TempGamma+GIntegral(i)*Step;
       end;
       ShortGamma:=TempGamma;
       end;
{- Factor ----------------------------------------------------------------------------}
   function Factor(n,step:extended):extended;
     var i:integer;
         NewGamma:extended;
     begin
     if (n<0) then
       if (trunc(n)=n) then begin
          Factor:=0;
          RaisedError:='factor results to infinite value';
          CalcError:=true;
          ErrorPosition:=0;
          exit;
        end else begin
            NewGamma:=ShortGamma(abs(1+frac(n))+1,step,50+abs(trunc(n*1.2)));
            for i:=-1 to trunc(abs(n))-1 do begin
                NewGamma:=NewGamma/(frac(n)-i);
                end;
            Factor:=NewGamma;
        end else
     if n=0 then Factor:=1 else
     if n=1 then Factor:=1 else
     if n=2 then Factor:=2 else
     if n=3 then Factor:=6 else
     Factor:=ShortGamma(n+1,step,50+trunc(n*1.2));
    end;
function Gamma(Alpha:extended;Step:extended):extended;
begin
   Gamma:=Factor(Alpha-1,Step);
   end;
function Beta(a,b,Step: extended): extended;
begin
   Beta:=Gamma(a,step)*Gamma(b,step)/Gamma(a+b,step);
   end;
{-------------------------------------------------------------------------------------}
function Precise(Value:extended;DecimalPrecision:integer):extended;
var NewValue:extended;
begin
   try
     NewValue:=Value*(Power(10,DecimalPrecision));
     NewValue:=Trunc(NewValue);
     NewValue:=NewValue/(Power(10,DecimalPrecision));
     Precise:=NewValue;
     except
     Precise:=Value;
     end;
   end;
{- Coth -------------------------------------------------------------------------------}
function Coth(g:extended):extended;
begin
   if exp(g)=exp(-g) then begin
      RaisedError:='division by zero at Coth()';
      CalcError:=true;
      ErrorPosition:=0;
      Coth:=0;
      exit;
      end;
   Coth:=(exp(g)+exp(-g))/(exp(g)-exp(-g));
   end;
{- MyRandom ---------------------------------------------------------------------------}
function MyRandom(g:extended):extended;
begin
   Randomize;
   if g<=0 then begin
      RaisedError:='senseless random request';
      CalcError:=true;
      ErrorPosition:=0;
      MyRandom:=0;
      exit;
      end;
   MyRandom:= Random(trunc(g));
   end;
{- Sec -------------------------------------------------------------------------}
function Sec(g:extended):extended;
begin
   if CalcMode=deg then g:=DegToRad(g);
   if Precise(Cos(g),10)=0 then begin
      Sec:=0;
      RaisedError:='division by zero at Sec()';
      CalcError:=true;
      ErrorPosition:=0;
      exit;
      end;
   Sec:= 1/Precise(cos(g),10);
   end;
{- MySqrt ----------------------------------------------------------------------}
function MySqrt(g:extended):extended;
begin
   if g<0 then begin
      MySqrt:=0;
      RaisedError:='sqrt of a negative value';
      CalcError:=true;
      ErrorPosition:=0;
      exit;
      end;
   MySqrt:= sqrt(g)
   end;
{- MySin ------------------------------------------------------------------------}
function MySin(g:extended):extended;
begin
   if CalcMode=deg then g:=DegToRad(g);
   MySin:=Precise(Sin(g),10);
   end;
{- MyCos ------------------------------------------------------------------------}
function MyCos(g:extended):extended;
begin
   if CalcMode=deg then g:=DegToRad(g);
   MyCos:= Precise(Cos(g),10);
   end;
{- MyTan ------------------------------------------------------------------------}
function MyTan(g:extended):extended;
begin
   if CalcMode=deg then g:=DegToRad(g);
   if Precise(Cos(g),10)=0 then begin
      MyTan:=0;
      RaisedError:='division by zero at Tan()';
      CalcError:=true;
      ErrorPosition:=0;
      exit;
      MyTan:=0;
      exit;
      end;
   MyTan:=Precise(Tan(g),10);{Precise(Sin(g),10)/Precise(Cos(g),10);}
   end;
{- MyArcSin ---------------------------------------------------------------------}
function MyArcSin(g:extended):extended;
begin
   if (1-sqr(g))<0 then begin
      RaisedError:='sqrt of negative value at ArcSin()';
      CalcError:=true;
      ErrorPosition:=0;
      MyArcSin:=0;
      exit;
      end;
   if sqrt(1-sqr(g))=0 then begin
      RaisedError:='division by zero at ArcSin()';
      CalcError:=true;
      ErrorPosition:=0;
      MyArcSin:=0;
      exit;
      end;
      {Evaluation:= ArcSin(g);{Precise(ArcTan (g/sqrt(1-sqr (g))),10);}
   if CalcMode=deg then MyArcSin:=RadToDeg(ArcSin(g)) else
      MyArcSin:=ArcSin(g);
   end;
{- MyArcCos --------------------------------------------------------------------}
function MyArcCos(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcCos()';
      CalcError:=true;
      ErrorPosition:=0;
      MyArcCos:=0;
      exit;
      end;
   if (1-sqr(g))<0 then begin
      RaisedError:='sqrt of negative value at ArcCos()';
      CalcError:=true;
      ErrorPosition:=0;
      MyArcCos:=0;
      exit;
      end;
   {Evaluation:= ArcCos(g);{Precise(ArcTan (sqrt (1-sqr (g)) /g),10);}
   if CalcMode=deg then MyArcCos:=RadToDeg(ArcCos(g)) else
      MyArcCos:=ArcCos(g);
   end;
{- MyArcCosH--------------------------------------------------------------------}
function MyArcCosh(g:extended):extended;
begin
   if g<1 then begin
      RaisedError:='sqrt of negative value at ArcCosh()';
      CalcError:=true;
      ErrorPosition:=0;
      MyArcCosh:=0;
      exit;
      end;
      MyArcCosh:=ArcCosh(g);
   end;
{- MyArcTanh -------------------------------------------------------------------}
function MyArcTanh(g:extended):extended;
begin
   if Abs(g)>1 then begin
      RaisedError:='out of domain at ArcTanh()';
      CalcError:=true;
      ErrorPosition:=0;
      MyArcTanh:=0;
      exit;
      end;
      MyArcTanh:=ArcTanh(g);
   end;
{- MyArcTan --------------------------------------------------------------------}
function MyArcTan(g:extended):extended;
begin
      if CalcMode=deg then MyArcTan:=RadToDeg(ArcTan(g)) else
      MyArcTan:=ArcTan(g)
   end;
{- MyCot ------------------------------------------------------------------------}
function MyCot(g:extended):extended;
begin
   if CalcMode=deg then g:=DegToRad(g);
   if Precise(g,10)=0 then begin
      RaisedError:='division by zero at Cot()';
      CalcError:=true;
      ErrorPosition:=0;
      MyCot:=0;
      exit;
      end;
   MyCot:= Cotan(g);
   {Precise(Cos(g),10)/Precise(Sin(g),10);}
   end;
{- MyCsch------------------------------------------------------------------------}
function MyCsch(g:extended):extended;
begin
   if Precise(Sinh(g),10)=0 then begin
      RaisedError:='division by zero at Csch()';
      CalcError:=true;
      ErrorPosition:=0;
      MyCsch:=0;
      exit;
      end;
   MyCsch:=1/Sinh(g);
   end;
{- MySech -----------------------------------------------------------------------}
function MySech(g:extended):extended;
begin
   if Precise(Cosh(g),10)=0 then begin
      RaisedError:='division by zero at Sech()';
      CalcError:=true;
      ErrorPosition:=0;
      MySech:=0;
      exit;
      end;
   MySech:=1/Cosh(g);
   end;
{- MyCsc ------------------------------------------------------------------------}
function MyCsc(g:extended):extended;
begin
   if CalcMode=deg then g:=DegToRad(g);
   if Precise(Sin(g),10)=0 then begin
      RaisedError:='division by zero at Csc()';
      CalcError:=true;
      ErrorPosition:=0;
      MyCsc:=0;
      exit;
      end;
   MyCsc:= 1/Precise(sin(g),10);
   end;
{- MyLn -------------------------------------------------------------------------}
function MyLn(g:extended):extended;
begin
   if g<=0 then begin
      RaisedError:='invalid natural log requested';
      CalcError:=true;
      ErrorPosition:=0;
      MyLn:=0;
      exit;
      end;
   MyLn:= ln(g);
   end;
{- MyLog ------------------------------------------------------------------------}
function MyLog(g:extended):extended;
begin
   if g<=0 then begin
      RaisedError:='invalid logarithm requested';
      CalcError:=true;
      ErrorPosition:=0;
      MyLog:=0;
      exit;
      end;
   {Evaluation:= ln(g)/ln(10);}
   MyLog:=log10(g);
   end;
{- ArcSec -----------------------------------------------------------------------}
function ArcSec(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcSec()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcSec:=0;
      exit;
      end;
   if abs(1/g)>1 then begin
      RaisedError:='value out of domain at ArcSec()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcSec:=0;
      exit;
      end;
  if CalcMode=deg then ArcSec:=RadToDeg(ArcCos(1/g)) else
     ArcSec:=ArcCos(1/g);
  end;
{- ArcCsc -----------------------------------------------------------------------}
function ArcCsc(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcCsc()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcCsc:=0;
      exit;
      end;
   if abs(1/g)>1 then begin
      RaisedError:='value out of domain at ArcCsc()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcCsc:=0;
      exit;
      end;
  if CalcMode=deg then ArcCsc:=RadToDeg(ArcSin(1/g)) else
     ArcCsc:=ArcSin(1/g);
   end;
{- ArcCot -----------------------------------------------------------------------}
function ArcCot(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcCot()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcCot:=0;
      exit;
      end;
   if CalcMode=deg then ArcCot:=RadToDeg(ArcTan(1/g)) else
      ArcCot:=ArcTan(1/g);
  end;
{- ArcSech -----------------------------------------------------------------------}
function ArcSech(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcSech()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcSech:=0;
      exit;
      end;
   if (1/g)<1 then begin
      RaisedError:='value out of domain at ArcSech()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcSech:=0;
      exit;
      end;
   ArcSech:=ArcCosh(1/g);
   end;
{- ArcCsch -----------------------------------------------------------------------}
function ArcCsch(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcCsch()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcCsch:=0;
      exit;
      end;
   ArcCsch:=ArcSinh(1/g);
   end;
{- ArcCoth -----------------------------------------------------------------------}
function ArcCoth(g:extended):extended;
begin
   if g=0 then begin
      RaisedError:='division by zero at ArcCoth()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcCoth:=0;
      exit;
      end;
   if Abs(1/g)>1 then begin
      RaisedError:='value out of domain at ArcCoth()';
      CalcError:=true;
      ErrorPosition:=0;
      ArcCoth:=0;
      exit;
      end;
      ArcCoth:=ArcTanh(1/g);
   end;
{- MyNot -----------------------------------------------------------------}
function MyNot(g:extended):extended;
begin
   if trunc(g)<>g then begin
      RaisedError:='logic functions require integers';
      CalcError:=true;
      ErrorPosition:=0;
      MyNot:=0;
      exit;
      end;
   MyNot:=Not(trunc(g));
   end;
{- MyShl -----------------------------------------------------------------}
function MyShr(g,d:extended):extended;forward;
function MyShl(g,d:extended):extended;
begin
   if d<0 then MyShl:=MyShr(g,-d) else
   if (trunc(g)<>g) or (trunc(d)<>d) then begin
      RaisedError:='logic functions require integers';
      CalcError:=true;
      ErrorPosition:=0;
      MyShl:=0;
      exit;
      end else
   MyShl:=trunc(g) shl trunc(d)
   end;
{- MyShr -----------------------------------------------------------------}
function MyShr(g,d:extended):extended;
begin
   if d<0 then MyShr:=MyShl(g,-d) else
   if (trunc(g)<>g) or (trunc(d)<>d) then begin
      RaisedError:='logic functions require integers';
      CalcError:=true;
      ErrorPosition:=0;
      MyShr:=0;
      exit;
      end else
   MyShr:=trunc(g)shr trunc(d)
   end;
{- Euler's Indice, the Phi function --------------------------------------}
(*
function eInd(g:extended):extended;
var
   UsedPrimes:PPrimesArray;
   UniquePrimesCount: longint;
   {-----------------}
   procedure UniquePrimesAdd(PrimeToAdd: LongInt);
   var
      i:LongInt;
   begin
        for i:=0 to UniquePrimesCount-1 do begin
            if UsedPrimes^[i]=PrimeToAdd then exit;
            end;
            Calculator.PrimesAdd(PrimeToAdd,UsedPrimes,UniquePrimesCount);
      end;
   procedure Factoring(lin:longint);
   var
      lcnt:longint;
      CurrentCounter:longint;
   begin
      if (Calculator.AllPrimes^[Calculator.PrimesCount-1]<lin) then MyPrime(lin);
      CurrentCounter:=2;
      lcnt:=Calculator.AllPrimes^[CurrentCounter];
      if MyPrime(lin)=lin then begin
         UniquePrimesAdd(lin);
         end else
         while(lcnt*lcnt<=lin) do begin
            if (lin mod lcnt) = 0 then begin
               if MyPrime(lcnt)<>lcnt then
                  factoring(lcnt) else UniquePrimesAdd(lcnt);
               if MyPrime(lin div lcnt)<>(lin div lcnt) then
                  factoring(lin div lcnt) else UniquePrimesAdd(lin div lcnt);
               exit;
               end;
          inc(CurrentCounter);
          lcnt:=Calculator.AllPrimes^[CurrentCounter];
         end;
      end;
   {-----------------}
   var
      FinalResult:extended;
      i: longint;
   begin
     UniquePrimesCount:=0;
     if trunc(g)<>g then begin
        RaisedError:='Euler''s indice requires integers';
        CalcError:=true;
        ErrorPosition:=0;
        eInd:=0;
        exit;
        end;
     if g=0 then begin
        eInd:=0;
        exit;
        end;
     g:=Abs(g);
     FinalResult:=g;
     UsedPrimes:=nil;
     Factoring(Round(g));
     for i:=0 to UniquePrimesCount-1 do begin
        FinalResult:=FinalResult*(1-1/UsedPrimes^[i]);
        end;
     eInd:=FinalResult;
     Calculator.PrimesRemove(UsedPrimes);
   end;
*)
function MyAverage(g: extended):extended;
var
   ChildValue: extended;
   CurrentAverage: extended;
   i:integer;
begin
   i:=1;
   CurrentAverage:=g;
   while (Expression^.Child(i)<>nil) do begin
         ChildValue:=Evaluation(Expression^.Child(i));
         CurrentAverage:=CurrentAverage+ChildValue;
         inc(i);
         end;
   MyAverage:=CurrentAverage/i;
   end;
{---------------}
function MyMin(g: extended):extended;
var
   ChildValue: extended;
   i:integer;
begin
   i:=1;
   while (Expression^.Child(i)<>nil) do begin
         ChildValue:=Evaluation(Expression^.Child(i));
         if ChildValue<g then g:=ChildValue;
         inc(i);
         end;
   MyMin:=g;
   end;
{-----------------------}
function MyMax(g: extended):extended;
var
   ChildValue: extended;
   i:integer;
begin
   i:=1;
   while (Expression^.Child(i)<>nil) do begin
         ChildValue:=Evaluation(Expression^.Child(i));
         if ChildValue>g then g:=ChildValue;
         inc(i);
         end;
   MyMax:=g;
   end;
{-------------------------}
(*
function MyPrimen(g: extended):extended;
var
   LocalCounter: longint;
begin
   if g<=0 then begin
      CalcError:=True;
      ErrorPosition:=0;
      RaisedError:='invalid PrimeN request';
      MyPrimeN:=0;
      exit;
      end;
   LocalCounter:=Calculator.AllPrimes[Calculator.PrimesCount-1];
   g:=g+1;
   while(Calculator.PrimesCount<=g) do begin
     MyPrime(LocalCounter);
     LocalCounter:=LocalCounter+2;
     end;
     MyPrimen:=Calculator.AllPrimes[trunc(g)];
   end;
{-------------------------}
function MyPrimeC(g: extended):extended;
var
   i: integer;
begin
   if g<0 then begin
      CalcError:=True;
      ErrorPosition:=0;
      RaisedError:='invalid PrimeC request';
      MyPrimeC:=0;
      exit;
      end;
   if (g>Calculator.CurrentPrime) then MyPrime(g);
   for i:=Calculator.PrimesCount-1 downto 0 do begin
   if  g>=Calculator.AllPrimes^[i] then begin
          MyPrimeC:=i-1;
          exit;
          end;
      end;
      CalcError:=True;
      ErrorPosition:=0;
      RaisedError:='unexpected PrimeC return value';
      MyPrimeC:=0;
      end;
{-----------------------}
*)
function Binom(n,j:extended):extended;
var
   _1Fact,_2Fact,_3Fact:extended;
begin
   _1Fact:=Factor(n,0.01);
   _2Fact:=Factor(j,0.01);
   _3Fact:=Factor(n-j,0.01);
   if (_2Fact=0) or (_3Fact=0) then begin
      CalcError:=True;
      ErrorPosition:=0;
      RaisedError:='factor in binom results to infinity';
      binom:=0;
      exit;
      end;
   Binom:=_1Fact/(_2Fact*_3Fact);
   end;
{----------------------}
var
   g, d : extended;
begin
  try
   Evaluation:=0;
   if CalcError=true then exit;
   if Expression^.Contents='=' then Evaluation:=Evaluation(Expression^.Child(0)) else
   if Expression^.NodeType = NodeValue then Evaluation := Expression^.NodeContents^.MyValue else
   if Expression^.NodeType = NodeVariable then Evaluation := VariableValue(Expression^.NodeContents^.MyVariable) else
   if Expression^.NodeType = NodeSingle then begin
       g := Evaluation(Expression^.Child(0));
       if Expression.NodeContents.MySingle[1]='-' then begin
       Delete(Expression.NodeContents.MySingle,1,1);
       NextInteger:=-1
       end else NextInteger:=1;
       if CompareText(Expression^.NodeContents^.MySingle,'binom')=0 then Evaluation:=NextInteger*Binom(g,Evaluation(Expression^.Child(1))) else
       if CompareText(Expression^.NodeContents^.MySingle,'perfect')=0 then Evaluation:=NextInteger*Perfect(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'mersgen')=0 then Evaluation:=NextInteger*PMersienne(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'genmers')=0 then Evaluation:=NextInteger*MersienneP(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'mersienne')=0 then Evaluation:=NextInteger*MersienneN(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'mersiennegen')=0 then Evaluation:=NextInteger*MersienneG(g) else
(*       if CompareText(Expression^.NodeContents^.MySingle,'primec')=0 then Evaluation:=NextInteger*MyPrimec(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'prime')=0 then Evaluation:=NextInteger*MyPrime(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'primen')=0 then Evaluation:=NextInteger*MyPrimen(g) else*)
{sin}  if CompareText(Expression^.NodeContents^.MySingle,'sin')=0 then Evaluation:=NextInteger*MySin(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'arcsin')=0 then Evaluation:=NextInteger*MyArcSin(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'sinh')=0 then Evaluation:=NextInteger*Sinh(g) else {(exp(g)-exp(-g))/2}
       if CompareText(Expression^.NodeContents^.MySingle,'arcsinh')=0 then Evaluation:=NextInteger*ArcSinh(g) else
{cos}  if CompareText(Expression^.NodeContents^.MySingle,'cos')=0 then Evaluation:=NextInteger*MyCos(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'arccos')=0 then Evaluation:=NextInteger*MyArcCos(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'cosh')=0 then Evaluation:= NextInteger*cosh(g){(exp(g)+exp(-g))/2} else
       if CompareText(Expression^.NodeContents^.MySingle,'arccosh')=0 then Evaluation:=NextInteger*MyArcCosh(g) else
{tan}  if CompareText(Expression^.NodeContents^.MySingle,'tan')=0 then Evaluation:=NextInteger*MyTan(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'arctan')=0 then Evaluation:=NextInteger*MyArcTan(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'tanh')=0 then Evaluation:=NextInteger*tanh(g) else {Evaluation:=(exp(g)-exp(-g))/(exp(g)+exp(-g)); {tanh has R for domain}
       if CompareText(Expression^.NodeContents^.MySingle,'arctanh')=0 then Evaluation:=NextInteger*MyArcTanh(g) else
{cot}  if CompareText(Expression^.NodeContents^.MySingle,'cot')=0 then Evaluation:=NextInteger*MyCot(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'coth')=0 then Evaluation:=NextInteger*coth(g) else
       if (CompareText(Expression^.NodeContents^.MySingle,'arccot')=0) then Evaluation:=NextInteger*arccot(g) else
       if (CompareText(Expression^.NodeContents^.MySingle,'arccoth')=0) then Evaluation:=NextInteger*arccoth(g) else
{sec}  if CompareText(Expression^.NodeContents^.MySingle,'sec')=0 then Evaluation:=NextInteger*Sec(g) else
       if (CompareText(Expression^.NodeContents^.MySingle,'arcsec')=0) then Evaluation:=NextInteger*arcsec(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'sech')=0 then Evaluation:=NextInteger*MySech(g) else
       if (CompareText(Expression^.NodeContents^.MySingle,'arcsech')=0) then Evaluation:=NextInteger*arcsech(g) else
{csc}  if CompareText(Expression^.NodeContents^.MySingle,'csc')=0 then Evaluation:=NextInteger*MyCsc(g) else
       if (CompareText(Expression^.NodeContents^.MySingle,'arccsc')=0) then Evaluation:=NextInteger*arccsc(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'csch')=0 then Evaluation:=NextInteger*MyCsch(g) else
       if (CompareText(Expression^.NodeContents^.MySingle,'arccsch')=0) then Evaluation:=NextInteger*arccsch(g) else
{etc}  if CompareText(Expression^.NodeContents^.MySingle,'new')=0 then Evaluation:=NextInteger*g else
       if CompareText(Expression^.NodeContents^.MySingle,'random')=0 then Evaluation:=NextInteger*MyRandom(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'sqr')=0 then Evaluation:= NextInteger*sqr(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'sqrt')=0 then Evaluation:= NextInteger*MySqrt(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'floor')=0 then Evaluation:=NextInteger*floor(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'ceil')=0 then Evaluation:=NextInteger*ceil(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'ln')=0 then Evaluation:=NextInteger*MyLn(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'exp')=0 then Evaluation:= NextInteger*exp(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'logn')=0 then Evaluation:=NextInteger*logn(g,Evaluation(Expression^.Child(1))) else
       if CompareText(Expression^.NodeContents^.MySingle,'log')=0 then Evaluation:=NextInteger*MyLog(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'trunc')=0 then Evaluation:= NextInteger*trunc(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'round')=0 then Evaluation:= NextInteger*round(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'int')=0 then Evaluation:= NextInteger*int(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'abs')=0 then Evaluation:= NextInteger*abs(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'frac')=0 then Evaluation:= NextInteger*(g-trunc(g)) else
       if CompareText(Expression^.NodeContents^.MySingle,'not')=0 then Evaluation:=NextInteger*MyNot(g) else
       (*if CompareText(Expression^.NodeContents^.MySingle,'eind')=0 then Evaluation:=NextInteger*eInd(g) else*)
       (*if CompareText(Expression^.NodeContents^.MySingle,'phi')=0 then Evaluation:=NextInteger*eInd(g) else*)
       if CompareText(Expression^.NodeContents^.MySingle,'max')=0 then Evaluation:=NextInteger*MyMax(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'min')=0 then Evaluation:=NextInteger*MyMin(g) else
       if CompareText(Expression^.NodeContents^.MySingle,'average')=0 then Evaluation:=NextInteger*MyAverage(g) else
      if CompareText(Expression^.NodeContents^.MySingle,'shl')=0 then Evaluation:=MyShl(g,Evaluation(Expression^.Child(1))) else
      if CompareText(Expression^.NodeContents^.MySingle,'shr')=0 then Evaluation:=MyShr(g,Evaluation(Expression^.Child(1))) else
      if CompareText(Expression^.NodeContents^.MySingle,'beta')=0 then Evaluation:=NextInteger*beta(g,Evaluation(Expression^.Child(1)),Evaluation(Expression^.Child(2))) else
      if CompareText(Expression^.NodeContents^.MySingle,'gamma')=0 then Evaluation:=NextInteger*Gamma(g,Evaluation(Expression^.Child(1))) else
      if CompareText(Expression^.NodeContents^.MySingle,'fib')=0 then begin
         if (trunc(g)<>g) or (g<0) then begin
            RaisedError:='fibonacci requires positive integers';
            CalcError:=true;
            ErrorPosition:=0;
            exit;
            end;
            Evaluation:=NextInteger*Fib(g);
         end else
      if CompareText(Expression^.NodeContents^.MySingle,'lcm')=0 then Evaluation:=NextInteger*lcm(g) else
      if CompareText(Expression^.NodeContents^.MySingle,'ppcm')=0 then Evaluation:=NextInteger*lcm(g) else
      if CompareText(Expression^.NodeContents^.MySingle,'pgcd')=0 then Evaluation:=NextInteger*gcd(g) else
      if CompareText(Expression^.NodeContents^.MySingle,'gcd')=0 then Evaluation:=NextInteger*gcd(g) else
       begin {else}
                RaisedError:='unknown function "'+Expression^.NodeContents^.MySingle+'"';
                CalcError:=true;
                ErrorPosition:=0;
                exit;
                end;
   end{else}
   else begin
      g := Evaluation(Expression^.Child(0));
      if CalcError=true then exit;
      d := Evaluation(Expression^.Child(1));
      if CalcError=true then exit;
      if (CompareText(Expression^.NodeContents^.MyOperator,'xor')=0) then Result:=trunc(g) xor trunc(d) else
      if (CompareText(Expression^.NodeContents^.MyOperator,'xnor')=0) then Result:=not(trunc(g) xor trunc(d)) else
      if (CompareText(Expression^.NodeContents^.MyOperator,'or')=0) then Result:=trunc(g) or trunc(d) else
      if (CompareText(Expression^.NodeContents^.MyOperator,'nor')=0) then Result:=not(trunc(g) or trunc(d)) else
      if (CompareText(Expression^.NodeContents^.MyOperator,'and')=0) then Result:=trunc(g) and trunc(d) else
      if (CompareText(Expression^.NodeContents^.MyOperator,'nand')=0) then Result:=not (trunc(g) and trunc(d)) else
      case Expression^.NodeContents^.MyOperator[1] of
         '&'   : Result:=trunc(g) and trunc(d);
         'm'   : Result:=trunc(g) mod trunc(d);
         '%'   : Result := (d/100)*g;
         '+'   : Result := g + d;
         '-'   : Result := g - d;
         '*'   : Result := g * d;
         'ª'   : begin {detects zero divisions!!!}
                 if d=0 then begin
                   RaisedError:='division by zero at int div';
                   CalcError:=true;
                   ErrorPosition:=0;
                   exit;
                   end;
                 Result := trunc(g/d);
                 end;
         '/'   : begin
                 Result:=g/d;
                 end;
         '^'   : begin
                 Result := Power(g,d);
                 if CalcError=true then exit;
                 end;
         '!'   : begin
                 Result := Factor(g,0.01);
                 if CalcError=true then exit;
                 end;
         '\'   : begin
                 if d=0 then Result:=0 else
                 if d>0 then Result:=Power(d,1/g)
                  else
                   if (Trunc(g)=g) and (odd(Trunc(g))) then Result:=-Power(-d,1/g)
                   else begin
                    RaisedError:='invalid root of negative value';
                    CalcError:=true;
                    ErrorPosition:=0;
                    exit;
                    end;
                  end;
         end;{case}
     Evaluation:=Result;
   end;{else}
   exit;
   except
      on EAccessViolation do RaisedError:='multithread collision, please retry';
      on EDivByZero  do RaisedError:='division by zero';
      on EIntOverFlow  do RaisedError:='integer overflow';
      on EInvalidOp  do RaisedError:='undefined instruction';
      on EOutOfMemory do RaisedError:='out of memory';
      on EOverflow do RaisedError:='floating point overflow';
      on ERangeError do RaisedError:='range check error';
      on EStackOverflow do RaisedError:='stack overflow';
      on EZeroDivide do RaisedError:='division by zero';
      on EUnderFlow  do RaisedError:='floating point underflow';
      else RaisedError:='general exception fault';
      end;{evaluation}
      CalcError:=true;
      ErrorPosition:=0;
      Evaluation:=0;
      exit;
   end;
end.